package lambdademo;

//@FunctionalInterface
//interface NoParameterNoReturn {
//    //函数式接口中只能有一个抽象方法
//    void test();
//    default void test1(){
//        System.out.println("test1");
//    }
//    public static void test2() {
//        System.out.println("test2");
//    }
//}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.function.Consumer;

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

public class TestLambda {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");

        list.forEach(new Consumer<String>(){
            public void accept(String s){
                System.out.println(s);
            }
        });
        //lambda简写
        list.forEach((s->System.out.println(s)));

//        list.sort(new Comparator<String>(){
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.compareTo(s2);
//            }
//        });

        list.sort((o1, o2) -> o1.compareTo(o2));
    }

    public static void main7(String[] args) {
        PriorityQueue<Integer> pq=new PriorityQueue<>(new Comparator<Integer>(){
            public int compare(Integer o1, Integer o2){
                return o1.compareTo(o2);
            }
        });

        //对上述代码进行lambda表达式重写
        PriorityQueue<Integer> pq1=new PriorityQueue<>((o1,o2)->o1.compareTo(o2));

    }
    public static void main6(String[] args) {
        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        System.out.println(moreParameterReturn.test(1, 2));
    }

    public static void main5(String[] args) {
        NoParameterReturn noParameterReturn=()->{return 10;};
        System.out.println(noParameterReturn.test());
    }

    public static void main4(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = (a,b)->System.out.println(a+b);
        moreParameterNoReturn.test(1,2);
    }

    public static void main3(String[] args) {
        OneParameterNoReturn oneParameterNoReturn=(g)->{System.out.println(g);};
        oneParameterNoReturn.test(10);
    }


    public static void main2(String[] args) {
        //使用lambda表达式的情况下使用函数式接口
        NoParameterNoReturn noParameterNoReturn=()->{System.out.println("test");};
        noParameterNoReturn.test();
    }
    public static void main1(String[] args) {
        //在没有lambda表达式的情况下使用函数式接口
        NoParameterNoReturn noParameterNoReturn=new NoParameterNoReturn() { //接口不能被实例化,后面加{}表示实例化为一个匿名内部类
            @Override
            public void test() {
                System.out.println("test");
            }
        };
        noParameterNoReturn.test();
    }
}
